# Developers: ----

# This file defines the parent class of FIMSFit and its potential children. The

# class is an S4 class with accessors and validators but no setters. For more

# details on how to create an S4 class in FIMS please see R/fimsframe.R

# TODO: ----

# TODO: Fix "no metadata object found to revise superClass" in sdreportOrList

# TODO: Write more validity checks for FIMSFit

# TODO: Better document the return of [get_estimates()], i.e., columns

# TODO: Decide if the error from is.FIMSFits should be a single FALSE or stop

# TODO: Decide if "total" should be a part of number_of_parameters because it

#       can be calculated from fixed_effects + random_effects and would need to

#       be calculated in print.FITFims()

# TODO: Determine if report should always use last.par.best

# TODO: Make a helper function to add lower and upper CI for users in estimates

# TODO: Add Terminal SB to print()

# methods::setClass: ----

# Need to use an S3 class for the following S4 class

methods::setOldClass(Classes = "package_version")

methods::setOldClass(Classes = "difftime")

methods::setOldClass(Classes = "sdreport")

# Join sdreport and list into a class incase the sdreport is not created

methods::setClassUnion("sdreportOrList", members = c("sdreport", "list"))

methods::setClass(

  Class = "FIMSFit",

  slots = c(

    input = "list",

    obj = "list",

    opt = "list",

    max_gradient = "numeric",

    report = "list",

    sdreport = "sdreportOrList",

    estimates = "tbl_df",

    number_of_parameters = "integer",

    timing = "difftime",

    version = "package_version"

  )

)

methods::setMethod(

  f = "print",

  signature = "FIMSFit",

  definition = function(x) {

    }

    )

    )

      # TODO: x@rep[["sb"]] does not exist

    ))

  }

)

# methods::setMethod: accessors ----

# Accessor functions for a FIMSFit object

# 1 methods::setGeneric() per slot but potentially >1 methods::setMethod() per methods::setGeneric()

#' Get a slot in a FIMSFit object

#'

#' There is an accessor function for each slot in the S4 class `FIMSFit`, where

#' the function is named `get_*()` and the star can be replaced with the slot

#' name, e.g., [get_input()]. These accessor functions are the preferred way

#' to access objects stored in the available slots.

#'

#' @param x Output returned from [fit_fims()].

#' @name get_FIMSFit

#' @seealso

#' * [fit_fims()]

#' * [create_default_parameters()]

NULL

#' @return

#' [get_input()] returns the list that was used to fit the FIMS model, which

#' is the returned object from [create_default_parameters()].

#' @export

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @return

#' [get_report()] returns the TMB report, where anything that is flagged as

#' reportable in the C++ code is returned.

#' @export

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @return

#' [get_obj()] returns the output from [TMB::MakeADFun()].

#' @export

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @return

#' [get_opt()] returns the output from [nlminb()], which is the minimizer used

#' in [fit_fims()].

#' @export

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @return

#' [get_max_gradient()] returns the maximum gradient found when optimizing the

#' model.

#' @export

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @return

#' [get_sdreport()] returns the list from [TMB::sdreport()].

#' @export

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @return

#' [get_estimates()] returns a tibble of parameter values and their

#' uncertainties from a fitted model.

#' @export

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @return

#' [get_number_of_parameters()] returns a vector of integers specifying the

#' number of fixed-effect parameters and the number of random-effect parameters

#' in the model.

#' @export

#' @rdname get_FIMSFit

#' @keywords fit_fims

methods::setGeneric(

  "get_number_of_parameters",

)

#' @rdname get_FIMSFit

#' @keywords fit_fims

methods::setMethod(

  "get_number_of_parameters",

  "FIMSFit",

)

#' @return

#' [get_timing()] returns the amount of time it took to run the model in

#' seconds as a `difftime` object.

#' @export

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @return

#' [get_version()] returns the `package_version` of FIMS that was used to fit

#' the model.

#' @export

#' @rdname get_FIMSFit

#' @keywords fit_fims

#' @rdname get_FIMSFit

#' @keywords fit_fims

# methods::setValidity ----

methods::setValidity(

  Class = "FIMSFit",

  method = function(object) {

    errors <- character()

    # Check that obj is from TMB::MakeADFun()

    TMB_MakeADFun_names <- c(

      "par", "fn", "gr", "he", "hessian", "method", "retape", "env", "report",

      "simulate"

    )

    if (!setequal(names(object@obj), TMB_MakeADFun_names)) {

      errors <- c(

        errors,

        "obj must be a list returned from TMB::MakeADFun() but it does not

        appear to be so because it does not have the standard names."

      )

    }

    # Return

    if (length(errors) == 0) {

      return(TRUE)

    } else {

      return(errors)

    }

  }

)

# methods::setMethod: is.FIMSFit ----

#' Check if an object is of class FIMSFit

#'

#' @param x Returned list from [fit_fims()].

#' @keywords fit_fims

#' @export

is.FIMSFit <- function(x) {

}

#' Check if an object is a list of FIMSFit objects

#'

#' @param x List of fits returned from multiple calls to [fit_fims()].

#' @keywords fit_fims

#' @export

is.FIMSFits <- function(x) {

    )

  }

}

# Constructors ----

#' Class constructors for class `FIMSFit` and associated child classes

#'

#' Create an object with the class of `FIMSFit` after running a FIMS model. This

#' is typically done within [fit_fims()] but it can be create manually by the

#' user if they have used their own bespoke code to fit a FIMS model.

#'

#' @inheritParams fit_fims

#' @param obj An object returned from [TMB::MakeADFun()].

#' @param opt An object returned from an optimizer, typically from

#'   [stats::nlminb()], used to fit a TMB model.

#' @param sdreport An object of the `sdreport` class as returned from

#'   [TMB::sdreport()].

#' @param timing A vector of at least length one, where all entries are of the

#'   `timediff` class and at least one is named "time_total". This information

#'   is available in [fit_fims()] and added to this argument internally but if

#'   you are a power user you can calculate the time it took to run your model

#'   by subtracting two [Sys.time()] objects.

#' @param version The version of FIMS that was used to optimize the model. If

#'   [fit_fims()] was not used to optimize the model, then the default is to

#'   use the current version of the package that is loaded.

#'

#' @return

#' An object with an S4 class of `FIMSFit` is returned. The object will have the

#' following slots:

#'   \describe{

#'     \item{\code{input}:}{

#'       A list containing the model setup in the same form it was passed.

#'     }

#'     \item{\code{obj}:}{

#'       A list returned from [TMB::MakeADFun()] in the same form it was passed.

#'     }

#'     \item{\code{opt}:}{

#'       A list containing the optimized model in the same form it was passed.

#'     }

#'     \item{\code{max_gradient}:}{

#'       The maximum gradient found when optimizing the model. The default is

#'       `NA`, which means that the model was not optimized.

#'     }

#'     \item{\code{report}:}{

#'       A list containing the model report from `obj[["report"]]()`.

#'     }

#'     \item{\code{sdreport}:}{

#'       A object with the `sdreport` class containing the output from

#'       `TMB::sdreport(obj)`.

#'     }

#'     \item{\code{estimates}:}{

#'       A table of parameter values and their uncertainty.

#'     }

#'     \item{\code{timing}:}{

#'       The length of time it took to run the model if it was optimized.

#'     }

#'     \item{\code{version}:}{

#'       The package version of FIMS used to fit the model or at least the

#'       version used to create this output, which will not always be the same

#'       if you are running this function yourself.

#'     }

#'  }

#' @keywords fit_fims

#' @export

FIMSFit <- function(

  input,

  obj,

  opt = list(),

  sdreport = list(),

  timing = c("time_total" = as.difftime(0, units = "secs")),

  version = utils::packageVersion("FIMS")

) {

  # What we aspire the estimate table to look like

  )

  # Determine the number of parameters

  )

  # Calculate the maximum gradient

  } else {

  }

  # Rename parameters instead of "p"

  # Get the report

  } else {

  }

    ) |>

      )

  } else {

    )

  }

  )

}

#' Fit a FIMS model (BETA)

#'

#' @param input Input list as returned by [initialize_fims()].

#' @param get_sd A boolean specifying if the [TMB::sdreport()] should be

#'   calculated?

#' @param save_sd A logical, with the default `TRUE`, indicating whether the

#'   sdreport is returned in the output. If `FALSE`, the slot for the report

#'   will be empty.

#' @param number_of_loops A positive integer specifying the number of

#'   iterations of the optimizer that will be performed to improve the

#'   gradient. The default is three, leading to four total optimization steps.

#' @param optimize Optimize (TRUE, default) or (FALSE) build and return

#'   a list containing the obj and report slot.

#' @param number_of_newton_steps The number of Newton steps using the inverse

#'   Hessian to do after optimization. Not yet implemented.

#' @param control A list of optimizer settings passed to [stats::nlminb()]. The

#'   the default is a list of length three with `eval.max = 1000`,

#'   `iter.max = 10000`, and `trace = 0`.

#' @param filename Character string giving a file name to save the fitted

#'   object as an RDS object. Defaults to 'fit.RDS', and a value of NULL

#'   indicates not to save it. If specified, it must end in .RDS. The file is

#'   written to folder given by `input[["path"]]`. Not yet implemented.

#' @return

#' An object of class `FIMSFit` is returned, where the structure is the same

#' regardless if `optimize = TRUE` or not. Uncertainty information is only

#' included in the `estimates` slot if `get_sd = TRUE`.

#' @seealso

#' * [FIMSFit()]

#' @details This function is a beta version still and subject to change

#'   without warning.

#' @keywords fit_fims

#' @export

fit_fims <- function(input,

                     get_sd = TRUE,

                     save_sd = TRUE,

                     number_of_loops = 3,

                     optimize = TRUE,

                     number_of_newton_steps = 0,

                     control = list(

                       eval.max = 10000,

                       iter.max = 10000,

                       trace = 0

                     ),

                     filename = NULL) {

  }

  }

  }

  )

    )

  }

  }

  ## optimize and compare

    )

  )

    ))

      # control$trace is reset to zero regardless of verbosity because the

      # differences in values printed out using control$trace will be

      # negligible between these different runs and is not worth printing

        )

      )

    }

    ))

  }

  } else {

  }

  )

  )

    ))

    # saveRDS(fit, file=file.path(input[["path"]], filename))

  }

}

# we create an as.list method for this new FIMSFit

methods::setMethod("as.list", signature(x = "FIMSFit"), function(x) {

      # apply as.list if the slot is again an user-defined object

      # therefore, as.list gets applied recursively

      } else {

        # otherwise just return the slot

      }

    },

  )

})

#' Validity checks for distributions

#'

#' This function checks the validity of arguments passed to functions that

#' relate to distributions within the Fisheries Integrated Modeling System

#' (FIMS). This function is designed to fail early only once, otherwise it goes

#' through many checks before reporting the results in an attempt to give the

#' user the most information possible. If it were to fail on every mistake,

#' then the user might have to iterate through multiple changes to their input

#' values. Sometimes, their mistakes might take quite a bit of time to make it

#' to this function or worse they might be running things on the cloud and not

#' have immediate access to the report. Therefore, we feel that providing the

#' most information possible is the best way forward.

#'

#' @param args A named list of input arguments that must contain at least

#'   `family` and `sd`. `data_type` is only needed for some upstream functions.

#' @seealso

#' This function is used in the following functions:

#' * [initialize_data_distribution()]

#' * [initialize_process_distribution()]

#' @noRd

#' @return

#' If successful, `TRUE` is invisibly returned. If unsuccessful,

#' [cli::cli_abort()] is used to return the relevant error messages.

check_distribution_validity <- function(args) {

  # Separate objects from args

  # Optional argument data_type

  # Set up global rules

  # FIXME: Move this to a data item in the package so it can be used everywhere

  # Could do a call to all data objects in the package and get unique types that

  # are available

  } else {

    )

  }

  # Start a bulleted list of errors and add to it in each if statement

  )

    )

    # Abort early because not all of the necessary items were in args

  }

  # Checks related to the family class

    )

  }

  if (

  ) {

    )

    )

  }

  # Checks related to the type of data

      )

    }

  }

  # Checks related to standard deviation

  # Check if sd has both elements and if yes, then go onto the else statement

  # for major checks

    )

  } else {

      )

    }

    if (

    ) {

      )

    }

  }

  # Return error messages if more than just the default is present

  } else {

  }

}

#' Return name of expected value

#'

#' The combination of data type, family, and link lead to a specific name for

#' the expected value within the code base. This function looks at the

#' combination of these three objects and specifies the appropriate string for

#' its name going forward.

#' @inheritParams initialize_data_distribution

#' @noRd

#' @return

#' A string specifying the name of the expected value.

#'

get_expected_name <- function(family, data_type) {

  # TODO: Think about if the name of the expected value should change based on

  # the link or if it should stay the same? Keeping track of different names in

  # the code base might be too complex for the output as well

  )

  # Check combination of entries was okay and led to valid name

    ))

  }

}

#' Set up a new distribution for a data type or a process

#'

#' Use [methods::new()] to set up a distribution within an existing module with

#' the necessary linkages between the two. For example, a fleet module will need

#' a distributional assumption for parts of the data associated with it, which

#' requires the use of `initialize_data_distribution()`, and a recruitment

#' module, like the Beverton--Holt stock--recruit relationship, will need a

#' distribution associated with the recruitment deviations, which requires

#' `initialize_process_distribution()`.

#' @param module An identifier to a C++ fleet module that is linked to the data

#'   of interest.

#' @param family A description of the error distribution and link function to

#'   be used in the model. The argument takes a family class, e.g.,

#'   `stats::gaussian(link = "identity")`.

#' @param sd A list of length two. The first entry is named `"value"` and it

#'   stores the initial values (scalar or vector) for the relevant standard

#'   deviations. The default is `value = 1`. The second entry is named

#'  `"estimated"` and it stores a vector of booleans (default = FALSE) is a

#'   scalar indicating whether or not standard deviation is estimated. If

#'   `"value"` is a vector and `"estimated"` is a scalar, the single value

#'   specified `"estimated"` value will be repeated to match the length of

#'   `value`. Otherwise, the dimensions of the two must match.

#' @param data_type A string specifying the type of data that the

#'   distribution will be fit to. Allowable types include

#'   `r toString(formals(initialize_data_distribution)[["data_type"]])`

#'   and the default is

#'   `r toString(formals(initialize_data_distribution)[["data_type"]][1])`.

#' @param par A string specifying the parameter name the distribution applies

#'   to. Parameters must be members of the specified module. Use

#'   `methods::show(module)` to obtain names of parameters within the module.

#' @param is_random_effect A boolean indicating whether or not the process is

#'   estimated as a random effect.

#' @return

#' A reference class. is returned. Use [methods::show()] to view the various

#' Rcpp class fields, methods, and documentation.

#' @keywords distribution

#' @export

#' @examples

#' \dontrun{

#' # Set up a new data distribution

#' n_years <- 30

#' # Create a new fleet module

#' fleet <- methods::new(Fleet)

#' # Create a distribution for the fleet module

#' fleet_distribution <- initialize_data_distribution(

#'   module = fishing_fleet,

#'   family = lognormal(link = "log"),

#'   sd = list(

#'     value = rep(sqrt(log(0.01^2 + 1)), n_years),

#'     estimated = rep(FALSE, n_years) # Could also be a single FALSE

#'   ),

#'   data_type = "index"

#' )

#'

#' # Set up a new process distribution

#' # Create a new recruitment module

#' recruitment <- methods::new(BevertonHoltRecruitment)

#' # view parameter names of the recruitment module

#' methods::show(BevertonHoltRecruitment)

#' # Create a distribution for the recruitment module

#' recruitment_distribution <- initialize_process_distribution(

#'   module = recruitment,

#'   par = "log_devs",

#'   family = gaussian(),

#'   sd = list(value = 0.4, estimated = FALSE),

#'   is_random_effect = FALSE

#' )

#' }

initialize_data_distribution <- function(

  module,

  family,

  sd = list(value = 1, estimated = FALSE),

  # FIXME: Move this argument to second to match where par is in

  # initialize_process_distribution

  data_type = c("index", "agecomp", "lengthcomp")

) {

  # FIXME: Make the available families a data object

  # Could also make the matrix of distributions available per type as a

  # data frame where the check could use the stored object.

  # validity check on user input

  )

  # assign name of observed data based on data_type

  # Set up distribution based on `family` argument`

    # create new Rcpp module

    # populate logged standard deviation parameter with log of input

    )

    # setup whether or not sd parameter is estimated

    } else {

      }

    }

  }

    # create new Rcpp module

    # populate logged standard deviation parameter with log of input

    }

    # setup whether or not sd parameter is estimated

    } else {

      }

    }

  }

    # create new Rcpp module

  }

  # setup link to observed data

  }

  }

  }

  # set name of expected values

  # setup link to expected values

}

#' @rdname initialize_data_distribution

#' @keywords distribution

#' @export

initialize_process_distribution <- function(

  module,

  par,

  family,

  sd = list(value = 1, estimated = FALSE),

  is_random_effect = FALSE

) {

  # validity check on user input

  # Set up distribution based on `family` argument`

    # create new Rcpp module

    # populate logged standard deviation parameter with log of input

    )

    # setup whether or not sd parameter is estimated

    } else {

      }

    }

  }

    # create new Rcpp module

    # populate logged standard deviation parameter with log of input

    }

    # setup whether or not sd parameter is estimated

    } else {

      }

    }

  }

  # indicate whether or not parameter is treated as a random effect in the model

  # create new Rcpp modules

  # initialize values with 0

  # these are overwritten in the code later by user input

  }

  # setup links to parameter

  )

}

#' Distributions not available in the stats package

#'

#' Family objects provide a convenient way to specify the details of the models

#' used by functions such as [stats::glm()]. These functions within this

#' package are not available within the stats package but are designed in a

#' similar manner.

#'

#' @param link A string specifying the model link function. For example,

#'   `"identity"` or `"log"` are appropriate names for the [stats::gaussian()]

#'   distribution. `"log"` and `"logit"` are the defaults for the lognormal and

#'   the multinomial, respectively.

#' @return

#' An object of class `family` (which has a concise print method). This

#' particular family has a truncated length compared to other distributions in

#' [stats::family()].

#' \item{family}{character: the family name.}

#' \item{link}{character: the link name.}

#'

#' @seealso

#' * [stats::family()]

#' * [stats::gaussian()]

#' * [stats::glm()]

#' * [stats::power()]

#' * [stats::make.link()]

#' @keywords distribution

#' @export

#' @examples

#' a_family <- multinomial()

#' a_family[["family"]]

#' a_family[["link"]]

lognormal <- function(link = "log") {

  )

}

#' @rdname lognormal

#' @keywords distribution

#' @export

multinomial <- function(link = "logit") {

  )

}

Rcpp::loadModule(module = "fims", what = TRUE)

.onUnload <- function(libpath) {

}

# Methods for Rcpp

#' Setter for `Rcpp_ParameterVector`

#'

#' In R, indexing starts at one. But, in C++ indexing starts at zero. These

#' functions do the translation for you so you can think in R terms.

#'

#' @param x A numeric vector.

#' @param i An integer specifying the location in R speak, where indexing

#'   starts at one, of the vector that you wish to set.

#' @param j Not used with `Rcpp_ParameterVector` because it is a vector.

#' @param value The value you want to set the indexed location to.

#' @return

#' For `[<-`, the index `i` of object `x` is set to `value`.

#' @keywords set_methods

#' @rdname Rcpp_ParameterVector

methods::setMethod(

  f = "[<-",

  signature = signature(

    x = "Rcpp_ParameterVector"

  ),

  definition = function(x, i, j, value) {

  }

)

#' Get information from Rcpp_ParameterVector

#'

#' In R, indexing starts at one. But, in C++ indexing starts at zero. This

#' function does the translation for you so you can think in R terms.

#'

#' @param x A numeric vector.

#' @param i An integer specifying the location in R speak, where indexing

#'   starts at one, of the vector that you wish to get information from.

#' @return

#' For `[`, the index `i` of object `x` is returned.

#' @keywords set_methods

#' @rdname Rcpp_ParameterVector

methods::setMethod(

  f = "[",

  signature = signature(x = "Rcpp_ParameterVector", i = "numeric"),

  definition = function(x, i) {

  }

)

#' Get the length of an Rcpp_ParameterVector

#'

#' @param x A numeric vector.

#' @return

#' For `length()`, the length of object `x` is returned as an integer.

#' @keywords set_methods

#' @rdname Rcpp_ParameterVector

methods::setMethod(

  f = "length",

  signature = signature(x = "Rcpp_ParameterVector"),

  definition = function(x) {

  }

)

#' Get the sum of all entries in an Rcpp_ParameterVector

#'

#' @param x A numeric vector.

#' @return

#' For `sum()`, the sum of object `x` is returned as a numeric value.

#' @keywords set_methods

#' @rdname Rcpp_ParameterVector

methods::setMethod(

  f = "sum",

  signature = signature(x = "Rcpp_ParameterVector"),

  definition = function(x) {

    }

  }

)

#' Get the dimensions of an Rcpp_ParameterVector

#'

#' @param x A numeric vector.

#' @return

#' For `dim()`, the dimensions of object `x` is returned as a single integer

#' because there is only one dimension to return for a vector.

#' @keywords set_methods

#' @rdname Rcpp_ParameterVector

methods::setMethod(

  f = "dim",

  signature = signature(x = "Rcpp_ParameterVector"),

  definition = function(x) {

  }

)

#' Sets methods for operators under the S4 Generic Group, Ops

#'

#' Ops include Arith (`+`, `-`, `*`, `^`, `%%`, `%/%`, and `/`);

#' Compare (`==`, `>`, `<`, `!=`, `<=`, and `>=`); and

#' Logic (`&`, `|`).

#'

#' @param e1,e2 An Rcpp_Parameter or Rcpp_ParameterVector class object or a

#'   numeric vector or value.

#' @return

#' A numeric or logical value(s) depending on the generic and the length of

#' the input values.

#' @keywords set_methods

#' @export

#' @rdname Rcpp_Math

methods::setMethod(

  "Ops",

  signature(e1 = "Rcpp_Parameter", e2 = "Rcpp_Parameter"),

  function(e1, e2) {

  }

)

#' @rdname Rcpp_Math

methods::setMethod(

  "Ops",

  signature(e1 = "Rcpp_Parameter", e2 = "numeric"),

  function(e1, e2) {

    }

  }

)

#' @rdname Rcpp_Math

methods::setMethod(

  "Ops", signature(e1 = "numeric", e2 = "Rcpp_Parameter"),

  function(e1, e2) {

    }

  }

)

#' @rdname Rcpp_Math

methods::setMethod(

  "Ops",

  signature(e1 = "Rcpp_ParameterVector", e2 = "Rcpp_ParameterVector"),

  function(e1, e2) {

    }

    }

  }

)

#' @rdname Rcpp_Math

methods::setMethod(

  "Ops",

  signature(e1 = "Rcpp_ParameterVector", e2 = "numeric"),

  function(e1, e2) {

        }

      }

    }

    }

  }

)

#' @rdname Rcpp_Math

methods::setMethod(

  "Ops",

  signature(e1 = "numeric", e2 = "Rcpp_ParameterVector"),

  function(e1, e2) {

        }

      }

    }

    }

  }

)

#' Sets methods for math functions for Rcpp_ParameterVector

#'

#' Methods of mathematical functions include trigonometry functions, `abs`,

#' `sign`, `sqrt`, `ceiling`, `floor`, `trunc`, `cummax`, `cumprod`, `cumsum`,

#' `log`, `log10`, `log2`, `log1p`, `exp`, `expm1`, `gamma`, `lgamma`,

#' `digamma`, and `trigamma`.

#'

#' @param x An Rcpp_ParameterVector class object.

#' @return

#' A vector of numeric values.

#' @keywords set_methods

#' @export

#' @rdname Rcpp_Math

methods::setMethod(

  "Math",

  signature(x = "Rcpp_ParameterVector"),

  function(x) {

    }

  }

)

#' Set methods for summary functions with an Rcpp_ParameterVector

#'

#' Methods of summary functions include `max`, `min`, `range`, `prod`, `sum`,

#' `any`, and `all`.

#'

#' @param x An Rcpp_ParameterVector class object.

#' @return

#' `Summary` returns a single or two numeric or logical values.

#' @export

#' @keywords set_methods

#' @rdname Rcpp_ParameterVector

methods::setMethod(

  "Summary",

  signature(x = "Rcpp_ParameterVector"),

  function(x) {

    }

  }

)

# To remove the WARNING

# no visible binding for global variable

utils::globalVariables(c(

  "type", "name", "value", "unit", "uncertainty",

  "datestart", "dateend", "age", "length", "year"

))

#' Initialize a generic module

#'

#' @description

#' Initializes a generic module by setting up its fields based on the provided

#' `module_name`.

#' @param parameters A list. Contains parameters and modules required for

#'   initialization.

#' @param data An S4 object. FIMS input data.

#' @param module_name A character. Name of the module to initialize (e.g.,

#'   "population" or "fleet").

#' @return

#' The initialized module as an object.

#' @noRd

initialize_module <- function(parameters, data, module_name) {

  # TODO: how to return all modules between pipes and create links between

  # modules?

  # # Retrieve all objects in the environment

  # objs <- mget(ls())

  # modules <- get_rcpp_modules(objs)

  # Input checks

  # Check if parameters is a list and contains the necessary sub-elements

    ))

  }

  # Validate module_name

  }

  # Check if module_name exists in the parameters list

  )) {

  }

  # Define module class and fields

  ) {

  ) {

  } else {

  }

    ))

      ))

    } else {

      ))

    }

    # TODO: refactor "age-to-length-conversion" in FIMSFrame data and

    # "age_length_conversion_matrix" in the Rcpp interface to

    # "age_to_legnth_conversion" for consistency

      # Assign each value to the corresponding position in the parameter vector

      }

      # Set the estimation information for the entire parameter vector

    } else {

        # Right now we can also remove nlengths because the default is 0

      ))

    }

    ))

  }

  # Populate fields based on common and specific settings

  # TODO:

  # - Population interface

  #   - Update the Population interface to consistently use n_ages and n_years,

  #     as done in the S4 data1 object.

  #   - Currently hard-coded `nseason` to 1 using the defaults from FIMS.

  #     Update as needed.

  #   - Add n_fleets to data1. Should n_fleets include both

  #     fishing and survey fleets? Currently, data1@fleets equals 1.

  # - Recruitment interface

  #   - Remove the field estimate_log_devs. It will be set up using the

  #   set_all_estimable() method instead.

  # - Fleet

  #   - Remove estimate_Fmort, estimate_q, and random_q from the Rcpp interface

  #   - Reconsider exposing `log_expected_index` and

  #     `proportion_catch_numbers_at_age` to users. Their IDs are linked with

  #     index and agecomp distributions. No input values are required.

  )

      # TODO: reorder the list alphabetically

        ]],

        ]],

        ))

      )

    } else {

      )

    }

  }

}

# TODO: Determine the relationship between distributions and the

# recruitment module, and implement the appropriate logic to retrieve

# distribution information.

#' Initialize a distribution module

#'

#' @description

#' Initializes a distribution module by setting up its fields based on the

#' distribution name and type. Supports both "data" and "process" types.

#' @param module_input A list. Contains parameters for initializing the

#'   distribution.

#' @param distribution_name A character. Name of the distribution to initialize.

#' @param distribution_type A character. Type of distribution, either "data" or

#'   "process".

#' @param linked_ids A vector. Named vector of linked IDs required for the

#'   distribution, such as data_link and fleet_link for setting up index

#'   distribution.

#' @rdname initialize_module

#' @return

#' The initialized distribution module as an object.

#' @noRd

initialize_distribution <- function(

  module_input,

  distribution_name,

  distribution_type = c("data", "process"),

  linked_ids

) {

  # Input checks

  # Check if distribution_name is provided

  }

  # Validate module_input

  }

  # Validate distribution_type as "data" or "process"

  # Validate linked_ids as a named vector with required elements for "data" type

  ) {

    )

  }

  # Get distribution value and initialize the module

    )

  }

  )

    )

  }

    "data" = {

      # Data distribution initialization

      )

    },

    "process" = {

      # Process distribution initialization